#include "order_process_manager.h"

Order_Process_Manager::Order_Process_Manager(QObject *parent)
    : QObject{parent}
{

}

bool Order_Process_Manager::isExistTable()
{
    Order_ProcessDataBase Db;

    QString sql = "SELECT ID, LeftAngle,RightAngle,MaterialHeight,MaterialLength,CutCount FROM Order_Process;";

    bool ok = Db.execSql(sql);
    if(!ok)
    {
        qDebug()<<"Cpp:不存在数据库表 Order_ProcessDataBase";

        sql = "CREATE TABLE Order_Process (ID INTEGER PRIMARY KEY ,LeftAngle TEXT,RightAngle TEXT,MaterialHeight TEXT,MaterialLength TEXT,CutCount TEXT);";
        qDebug()<<"Cpp:创建数据表 Order_ProcessDataBase sql:"<<sql;
        bool ok = Db.execSql(sql);
        if(ok)
        {
            qDebug()<<"Cpp:创建数据表 Order_ProcessDataBase 成功";

            for(int i = 0 ; i < 20* 20; i++)
            {
                addData();
            }

            for(int i =0 ;i < 20*20; i++)
            {
                saveData((i+1),"LeftAngle","45");
                saveData((i+1),"RightAngle","45");
                saveData((i+1),"MaterialHeight","0");
                saveData((i+1),"MaterialLength","0");
                saveData((i+1),"CutCount","0");
            }
        }
        else
        {
            qDebug()<<"Cpp:创建数据表 Order_Process 失败";
            return false;
        }
    }
    else
    {
        getDataByPacket(0);
    }

    return true;
}

void Order_Process_Manager::getAllDataFromSQL()
{

    Order_ProcessDataBase Db;

    QSharedPointer<QSqlQuery> result;

    QString sql = "SELECT ID, LeftAngle,RightAngle,MaterialHeight,MaterialLength,CutCount FROM Order_Process ;";

    // QString leftAngle;
    // QString rightAngle;
    // QString lg_Value;
    // QString lc_Value;
    // QString count;

    result.reset(Db.execSql_result(sql));
    if(!result.isNull())
    {
        while(result->next())
        {

            int id = result->value(0).toInt();

            switch(id)
            {
            case 1:
                // leftAngle = result->value(1).toString();
                // rightAngle = result->value(2).toString();
                // lg_Value = result->value(3).toString();
                // lc_Value = result->value(4).toString();
                // count = result->value(5).toString();
                setLeftAngle_01(result->value(1).toString());
                setRightAngle_01(result->value(2).toString());
                setMaterialHeight_01(result->value(3).toString());
                setMaterialLength_01(result->value(4).toString());
                setCutCount_01(result->value(5).toString());
                break;
            case 2 :
                setLeftAngle_02(result->value(1).toString());
                setRightAngle_02(result->value(2).toString());
                setMaterialHeight_02(result->value(3).toString());
                setMaterialLength_02(result->value(4).toString());
                setCutCount_02(result->value(5).toString());
                break;
            case 3:
                setLeftAngle_03(result->value(1).toString());
                setRightAngle_03(result->value(2).toString());
                setMaterialHeight_03(result->value(3).toString());
                setMaterialLength_03(result->value(4).toString());
                setCutCount_03(result->value(5).toString());
                break;
            case 4:
                setLeftAngle_04(result->value(1).toString());
                setRightAngle_04(result->value(2).toString());
                setMaterialHeight_04(result->value(3).toString());
                setMaterialLength_04(result->value(4).toString());
                setCutCount_04(result->value(5).toString());
                break;
            case 5:
                setLeftAngle_05(result->value(1).toString());
                setRightAngle_05(result->value(2).toString());
                setMaterialHeight_05(result->value(3).toString());
                setMaterialLength_05(result->value(4).toString());
                setCutCount_05(result->value(5).toString());
                break;
            case 6:
                setLeftAngle_06(result->value(1).toString());
                setRightAngle_06(result->value(2).toString());
                setMaterialHeight_06(result->value(3).toString());
                setMaterialLength_06(result->value(4).toString());
                setCutCount_06(result->value(5).toString());
                break;
            case 7:
                setLeftAngle_07(result->value(1).toString());
                setRightAngle_07(result->value(2).toString());
                setMaterialHeight_07(result->value(3).toString());
                setMaterialLength_07(result->value(4).toString());
                setCutCount_07(result->value(5).toString());
                break;
            case 8:
                setLeftAngle_08(result->value(1).toString());
                setRightAngle_08(result->value(2).toString());
                setMaterialHeight_08(result->value(3).toString());
                setMaterialLength_08(result->value(4).toString());
                setCutCount_08(result->value(5).toString());
                break;
            case 9:
                setLeftAngle_09(result->value(1).toString());
                setRightAngle_09(result->value(2).toString());
                setMaterialHeight_09(result->value(3).toString());
                setMaterialLength_09(result->value(4).toString());
                setCutCount_09(result->value(5).toString());
                break;
            case 10:
                setLeftAngle_10(result->value(1).toString());
                setRightAngle_10(result->value(2).toString());
                setMaterialHeight_10(result->value(3).toString());
                setMaterialLength_10(result->value(4).toString());
                setCutCount_10(result->value(5).toString());
                break;
            case 11:
                setLeftAngle_11(result->value(1).toString());
                setRightAngle_11(result->value(2).toString());
                setMaterialHeight_11(result->value(3).toString());
                setMaterialLength_11(result->value(4).toString());
                setCutCount_11(result->value(5).toString());
                break;
            case 12:
                setLeftAngle_12(result->value(1).toString());
                setRightAngle_12(result->value(2).toString());
                setMaterialHeight_12(result->value(3).toString());
                setMaterialLength_12(result->value(4).toString());
                setCutCount_12(result->value(5).toString());
                break;
            case 13:
                setLeftAngle_13(result->value(1).toString());
                setRightAngle_13(result->value(2).toString());
                setMaterialHeight_13(result->value(3).toString());
                setMaterialLength_13(result->value(4).toString());
                setCutCount_13(result->value(5).toString());
                break;
            case 14:
                setLeftAngle_14(result->value(1).toString());
                setRightAngle_14(result->value(2).toString());
                setMaterialHeight_14(result->value(3).toString());
                setMaterialLength_14(result->value(4).toString());
                setCutCount_14(result->value(5).toString());
                break;
            case 15:
                setLeftAngle_15(result->value(1).toString());
                setRightAngle_15(result->value(2).toString());
                setMaterialHeight_15(result->value(3).toString());
                setMaterialLength_15(result->value(4).toString());
                setCutCount_15(result->value(5).toString());
                break;
            case 16:
                setLeftAngle_16(result->value(1).toString());
                setRightAngle_16(result->value(2).toString());
                setMaterialHeight_16(result->value(3).toString());
                setMaterialLength_16(result->value(4).toString());
                setCutCount_16(result->value(5).toString());
                break;
            case 17:
                setLeftAngle_17(result->value(1).toString());
                setRightAngle_17(result->value(2).toString());
                setMaterialHeight_17(result->value(3).toString());
                setMaterialLength_17(result->value(4).toString());
                setCutCount_17(result->value(5).toString());
                break;
            case 18:
                setLeftAngle_18(result->value(1).toString());
                setRightAngle_18(result->value(2).toString());
                setMaterialHeight_18(result->value(3).toString());
                setMaterialLength_18(result->value(4).toString());
                setCutCount_18(result->value(5).toString());
                break;
            case 19:
                setLeftAngle_19(result->value(1).toString());
                setRightAngle_19(result->value(2).toString());
                setMaterialHeight_19(result->value(3).toString());
                setMaterialLength_19(result->value(4).toString());
                setCutCount_19(result->value(5).toString());
                break;
            case 20:
                setLeftAngle_20(result->value(1).toString());
                setRightAngle_20(result->value(2).toString());
                setMaterialHeight_20(result->value(3).toString());
                setMaterialLength_20(result->value(4).toString());
                setCutCount_20(result->value(5).toString());
                break;
            default:
                break;
            }

        }


        result.clear();
    }
}

void Order_Process_Manager::getDataByPacket(int packetNumber)
{
    Order_ProcessDataBase Db;

    QSharedPointer<QSqlQuery> result;


    int downlimit = (packetNumber * 20 + 1);

    int uplimit = (packetNumber * 20 + 20);

    QString sql = QString("SELECT ID, LeftAngle,RightAngle,MaterialHeight,MaterialLength,CutCount FROM Order_Process WHERE ID BETWEEN %1 AND %2 ;").arg(downlimit).arg(uplimit);


    result.reset(Db.execSql_result(sql));

    if(!result.isNull())
    {
        while(result->next())
        {
            int id = result->value(0).toInt();

            if(id == downlimit )
            {
                setLeftAngle_01(result->value(1).toString());
                setRightAngle_01(result->value(2).toString());
                setMaterialHeight_01(result->value(3).toString());
                setMaterialLength_01(result->value(4).toString());
                setCutCount_01(result->value(5).toString());
            }
            else if(id == (downlimit + 1) )
            {
                setLeftAngle_02(result->value(1).toString());
                setRightAngle_02(result->value(2).toString());
                setMaterialHeight_02(result->value(3).toString());
                setMaterialLength_02(result->value(4).toString());
                setCutCount_02(result->value(5).toString());
            }
            else if(id == (downlimit + 2) )
            {
                setLeftAngle_03(result->value(1).toString());
                setRightAngle_03(result->value(2).toString());
                setMaterialHeight_03(result->value(3).toString());
                setMaterialLength_03(result->value(4).toString());
                setCutCount_03(result->value(5).toString());
            }
            else if(id == (downlimit + 3) )
            {
                setLeftAngle_04(result->value(1).toString());
                setRightAngle_04(result->value(2).toString());
                setMaterialHeight_04(result->value(3).toString());
                setMaterialLength_04(result->value(4).toString());
                setCutCount_04(result->value(5).toString());
            }
            else if(id == (downlimit + 4) )
            {
                setLeftAngle_05(result->value(1).toString());
                setRightAngle_05(result->value(2).toString());
                setMaterialHeight_05(result->value(3).toString());
                setMaterialLength_05(result->value(4).toString());
                setCutCount_05(result->value(5).toString());
            }
            else if(id == (downlimit + 5))
            {
                setLeftAngle_06(result->value(1).toString());
                setRightAngle_06(result->value(2).toString());
                setMaterialHeight_06(result->value(3).toString());
                setMaterialLength_06(result->value(4).toString());
                setCutCount_06(result->value(5).toString());
            }
            else if(id == (downlimit + 6) )
            {
                setLeftAngle_07(result->value(1).toString());
                setRightAngle_07(result->value(2).toString());
                setMaterialHeight_07(result->value(3).toString());
                setMaterialLength_07(result->value(4).toString());
                setCutCount_07(result->value(5).toString());
            }
            else if(id == (downlimit + 7) )
            {
                setLeftAngle_08(result->value(1).toString());
                setRightAngle_08(result->value(2).toString());
                setMaterialHeight_08(result->value(3).toString());
                setMaterialLength_08(result->value(4).toString());
                setCutCount_08(result->value(5).toString());
            }
            else if(id == (downlimit + 8) )
            {
                setLeftAngle_09(result->value(1).toString());
                setRightAngle_09(result->value(2).toString());
                setMaterialHeight_09(result->value(3).toString());
                setMaterialLength_09(result->value(4).toString());
                setCutCount_09(result->value(5).toString());
            }
            else if(id == (downlimit + 9))
            {
                setLeftAngle_10(result->value(1).toString());
                setRightAngle_10(result->value(2).toString());
                setMaterialHeight_10(result->value(3).toString());
                setMaterialLength_10(result->value(4).toString());
                setCutCount_10(result->value(5).toString());
            }
            else if(id == (downlimit + 10) )
            {
                setLeftAngle_11(result->value(1).toString());
                setRightAngle_11(result->value(2).toString());
                setMaterialHeight_11(result->value(3).toString());
                setMaterialLength_11(result->value(4).toString());
                setCutCount_11(result->value(5).toString());
            }
            else if(id == (downlimit + 11))
            {
                setLeftAngle_12(result->value(1).toString());
                setRightAngle_12(result->value(2).toString());
                setMaterialHeight_12(result->value(3).toString());
                setMaterialLength_12(result->value(4).toString());
                setCutCount_12(result->value(5).toString());
            }
            else if(id == (downlimit + 12) )
            {
                setLeftAngle_13(result->value(1).toString());
                setRightAngle_13(result->value(2).toString());
                setMaterialHeight_13(result->value(3).toString());
                setMaterialLength_13(result->value(4).toString());
                setCutCount_13(result->value(5).toString());
            }
            else if(id == (downlimit + 13) )
            {
                setLeftAngle_14(result->value(1).toString());
                setRightAngle_14(result->value(2).toString());
                setMaterialHeight_14(result->value(3).toString());
                setMaterialLength_14(result->value(4).toString());
                setCutCount_14(result->value(5).toString());
            }
            else if(id == (downlimit + 14) )
            {
                setLeftAngle_15(result->value(1).toString());
                setRightAngle_15(result->value(2).toString());
                setMaterialHeight_15(result->value(3).toString());
                setMaterialLength_15(result->value(4).toString());
                setCutCount_15(result->value(5).toString());
            }
            else if(id == (downlimit + 15) )
            {
                setLeftAngle_16(result->value(1).toString());
                setRightAngle_16(result->value(2).toString());
                setMaterialHeight_16(result->value(3).toString());
                setMaterialLength_16(result->value(4).toString());
                setCutCount_16(result->value(5).toString());
            }
            else if(id == (downlimit + 16) )
            {
                setLeftAngle_17(result->value(1).toString());
                setRightAngle_17(result->value(2).toString());
                setMaterialHeight_17(result->value(3).toString());
                setMaterialLength_17(result->value(4).toString());
                setCutCount_17(result->value(5).toString());
            }
            else if(id == (downlimit + 17) )
            {
                setLeftAngle_18(result->value(1).toString());
                setRightAngle_18(result->value(2).toString());
                setMaterialHeight_18(result->value(3).toString());
                setMaterialLength_18(result->value(4).toString());
                setCutCount_18(result->value(5).toString());
            }
            else if(id == (downlimit + 18) )
            {
                setLeftAngle_19(result->value(1).toString());
                setRightAngle_19(result->value(2).toString());
                setMaterialHeight_19(result->value(3).toString());
                setMaterialLength_19(result->value(4).toString());
                setCutCount_19(result->value(5).toString());
            }
            else if(id == (downlimit + 19) )
            {
                setLeftAngle_20(result->value(1).toString());
                setRightAngle_20(result->value(2).toString());
                setMaterialHeight_20(result->value(3).toString());
                setMaterialLength_20(result->value(4).toString());
                setCutCount_20(result->value(5).toString());
            }
        }
    }
}

void Order_Process_Manager::addData()
{
    Order_ProcessDataBase Db;

    QString sql = "INSERT INTO Order_Process (LeftAngle , RightAngle , MaterialHeight , MaterialLength , CutCount) VALUES('','','','','')";

    qDebug()<<"Cpp:插入数据 sql:"<<sql;

    bool ok = Db.execSql(sql);
    if(!ok)
    {
        qDebug()<<"Cpp:添加数据失败";
    }
    else
    {
        qDebug()<<"Cpp:添加数据成功";
        getAllDataFromSQL();
    }
}

void Order_Process_Manager::saveData(int id, QString key, QString value)
{
    Order_ProcessDataBase Db;

    QString sql = "UPDATE Order_Process SET " + key + "='"+ value +"' WHERE ID = "+QString::number(id);

    qDebug()<<"Cpp:更新数据 sql:"<<sql;

    bool ok = Db.execSql(sql);

    if(!ok)
    {
        qDebug()<<"Cpp:更新数据失败";
    }
    else
    {
        qDebug()<<"Cpp:更新数据成功";
    }
}

void Order_Process_Manager::cleanAllData(int packetNumber)
{
    qDebug()<<"触发 清空数据库 数据 函数";

    for(int i = 1 ; i <= 20 ; i++)
    {
        saveData(packetNumber*20 + i,"LeftAngle","45");
        saveData(packetNumber*20 + i,"RightAngle","45");
        saveData(packetNumber*20 + i,"MaterialHeight","0");
        saveData(packetNumber*20 + i,"MaterialLength","0");
        saveData(packetNumber*20 + i,"CutCount","0");
    }

    getDataByPacket(packetNumber);

}

QString Order_Process_Manager::LeftAngle_01() const
{
    return m_LeftAngle_01;
}

void Order_Process_Manager::setLeftAngle_01(const QString &newLeftAngle_01)
{
    if (m_LeftAngle_01 == newLeftAngle_01)
        return;
    m_LeftAngle_01 = newLeftAngle_01;
    emit LeftAngle_01Changed();
}

QString Order_Process_Manager::RightAngle_01() const
{
    return m_RightAngle_01;
}

void Order_Process_Manager::setRightAngle_01(const QString &newRightAngle_01)
{
    if (m_RightAngle_01 == newRightAngle_01)
        return;
    m_RightAngle_01 = newRightAngle_01;
    emit RightAngle_01Changed();
}

QString Order_Process_Manager::MaterialHeight_01() const
{
    return m_MaterialHeight_01;
}

void Order_Process_Manager::setMaterialHeight_01(const QString &newMaterialHeight_01)
{
    if (m_MaterialHeight_01 == newMaterialHeight_01)
        return;
    m_MaterialHeight_01 = newMaterialHeight_01;
    emit MaterialHeight_01Changed();
}

QString Order_Process_Manager::MaterialLength_01() const
{
    return m_MaterialLength_01;
}

void Order_Process_Manager::setMaterialLength_01(const QString &newMaterialLength_01)
{
    if (m_MaterialLength_01 == newMaterialLength_01)
        return;
    m_MaterialLength_01 = newMaterialLength_01;
    emit MaterialLength_01Changed();
}

QString Order_Process_Manager::CutCount_01() const
{
    return m_CutCount_01;
}

void Order_Process_Manager::setCutCount_01(const QString &newCutCount_01)
{
    if (m_CutCount_01 == newCutCount_01)
        return;
    m_CutCount_01 = newCutCount_01;
    emit CutCount_01Changed();
}

QString Order_Process_Manager::LeftAngle_02() const
{
    return m_LeftAngle_02;
}

void Order_Process_Manager::setLeftAngle_02(const QString &newLeftAngle_02)
{
    if (m_LeftAngle_02 == newLeftAngle_02)
        return;
    m_LeftAngle_02 = newLeftAngle_02;
    emit LeftAngle_02Changed();
}

QString Order_Process_Manager::RightAngle_02() const
{
    return m_RightAngle_02;
}

void Order_Process_Manager::setRightAngle_02(const QString &newRightAngle_02)
{
    if (m_RightAngle_02 == newRightAngle_02)
        return;
    m_RightAngle_02 = newRightAngle_02;
    emit RightAngle_02Changed();
}

QString Order_Process_Manager::MaterialHeight_02() const
{
    return m_MaterialHeight_02;
}

void Order_Process_Manager::setMaterialHeight_02(const QString &newMaterialHeight_02)
{
    if (m_MaterialHeight_02 == newMaterialHeight_02)
        return;
    m_MaterialHeight_02 = newMaterialHeight_02;
    emit MaterialHeight_02Changed();
}

QString Order_Process_Manager::MaterialLength_02() const
{
    return m_MaterialLength_02;
}

void Order_Process_Manager::setMaterialLength_02(const QString &newMaterialLength_02)
{
    if (m_MaterialLength_02 == newMaterialLength_02)
        return;
    m_MaterialLength_02 = newMaterialLength_02;
    emit MaterialLength_02Changed();
}

QString Order_Process_Manager::CutCount_02() const
{
    return m_CutCount_02;
}

void Order_Process_Manager::setCutCount_02(const QString &newCutCount_02)
{
    if (m_CutCount_02 == newCutCount_02)
        return;
    m_CutCount_02 = newCutCount_02;
    emit CutCount_02Changed();
}

QString Order_Process_Manager::LeftAngle_03() const
{
    return m_LeftAngle_03;
}

void Order_Process_Manager::setLeftAngle_03(const QString &newLeftAngle_03)
{
    if (m_LeftAngle_03 == newLeftAngle_03)
        return;
    m_LeftAngle_03 = newLeftAngle_03;
    emit LeftAngle_03Changed();
}

QString Order_Process_Manager::RightAngle_03() const
{
    return m_RightAngle_03;
}

void Order_Process_Manager::setRightAngle_03(const QString &newRightAngle_03)
{
    if (m_RightAngle_03 == newRightAngle_03)
        return;
    m_RightAngle_03 = newRightAngle_03;
    emit RightAngle_03Changed();
}

QString Order_Process_Manager::MaterialHeight_03() const
{
    return m_MaterialHeight_03;
}

void Order_Process_Manager::setMaterialHeight_03(const QString &newMaterialHeight_03)
{
    if (m_MaterialHeight_03 == newMaterialHeight_03)
        return;
    m_MaterialHeight_03 = newMaterialHeight_03;
    emit MaterialHeight_03Changed();
}

QString Order_Process_Manager::MaterialLength_03() const
{
    return m_MaterialLength_03;
}

void Order_Process_Manager::setMaterialLength_03(const QString &newMaterialLength_03)
{
    if (m_MaterialLength_03 == newMaterialLength_03)
        return;
    m_MaterialLength_03 = newMaterialLength_03;
    emit MaterialLength_03Changed();
}

QString Order_Process_Manager::CutCount_03() const
{
    return m_CutCount_03;
}

void Order_Process_Manager::setCutCount_03(const QString &newCutCount_03)
{
    if (m_CutCount_03 == newCutCount_03)
        return;
    m_CutCount_03 = newCutCount_03;
    emit CutCount_03Changed();
}

QString Order_Process_Manager::LeftAngle_04() const
{
    return m_LeftAngle_04;
}

void Order_Process_Manager::setLeftAngle_04(const QString &newLeftAngle_04)
{
    if (m_LeftAngle_04 == newLeftAngle_04)
        return;
    m_LeftAngle_04 = newLeftAngle_04;
    emit LeftAngle_04Changed();
}

QString Order_Process_Manager::RightAngle_04() const
{
    return m_RightAngle_04;
}

void Order_Process_Manager::setRightAngle_04(const QString &newRightAngle_04)
{
    if (m_RightAngle_04 == newRightAngle_04)
        return;
    m_RightAngle_04 = newRightAngle_04;
    emit RightAngle_04Changed();
}

QString Order_Process_Manager::MaterialHeight_04() const
{
    return m_MaterialHeight_04;
}

void Order_Process_Manager::setMaterialHeight_04(const QString &newMaterialHeight_04)
{
    if (m_MaterialHeight_04 == newMaterialHeight_04)
        return;
    m_MaterialHeight_04 = newMaterialHeight_04;
    emit MaterialHeight_04Changed();
}

QString Order_Process_Manager::MaterialLength_04() const
{
    return m_MaterialLength_04;
}

void Order_Process_Manager::setMaterialLength_04(const QString &newMaterialLength_04)
{
    if (m_MaterialLength_04 == newMaterialLength_04)
        return;
    m_MaterialLength_04 = newMaterialLength_04;
    emit MaterialLength_04Changed();
}

QString Order_Process_Manager::CutCount_04() const
{
    return m_CutCount_04;
}

void Order_Process_Manager::setCutCount_04(const QString &newCutCount_04)
{
    if (m_CutCount_04 == newCutCount_04)
        return;
    m_CutCount_04 = newCutCount_04;
    emit CutCount_04Changed();
}

QString Order_Process_Manager::LeftAngle_05() const
{
    return m_LeftAngle_05;
}

void Order_Process_Manager::setLeftAngle_05(const QString &newLeftAngle_05)
{
    if (m_LeftAngle_05 == newLeftAngle_05)
        return;
    m_LeftAngle_05 = newLeftAngle_05;
    emit LeftAngle_05Changed();
}

QString Order_Process_Manager::RightAngle_05() const
{
    return m_RightAngle_05;
}

void Order_Process_Manager::setRightAngle_05(const QString &newRightAngle_05)
{
    if (m_RightAngle_05 == newRightAngle_05)
        return;
    m_RightAngle_05 = newRightAngle_05;
    emit RightAngle_05Changed();
}

QString Order_Process_Manager::MaterialHeight_05() const
{
    return m_MaterialHeight_05;
}

void Order_Process_Manager::setMaterialHeight_05(const QString &newMaterialHeight_05)
{
    if (m_MaterialHeight_05 == newMaterialHeight_05)
        return;
    m_MaterialHeight_05 = newMaterialHeight_05;
    emit MaterialHeight_05Changed();
}

QString Order_Process_Manager::MaterialLength_05() const
{
    return m_MaterialLength_05;
}

void Order_Process_Manager::setMaterialLength_05(const QString &newMaterialLength_05)
{
    if (m_MaterialLength_05 == newMaterialLength_05)
        return;
    m_MaterialLength_05 = newMaterialLength_05;
    emit MaterialLength_05Changed();
}

QString Order_Process_Manager::CutCount_05() const
{
    return m_CutCount_05;
}

void Order_Process_Manager::setCutCount_05(const QString &newCutCount_05)
{
    if (m_CutCount_05 == newCutCount_05)
        return;
    m_CutCount_05 = newCutCount_05;
    emit CutCount_05Changed();
}

QString Order_Process_Manager::LeftAngle_06() const
{
    return m_LeftAngle_06;
}

void Order_Process_Manager::setLeftAngle_06(const QString &newLeftAngle_06)
{
    if (m_LeftAngle_06 == newLeftAngle_06)
        return;
    m_LeftAngle_06 = newLeftAngle_06;
    emit LeftAngle_06Changed();
}

QString Order_Process_Manager::RightAngle_06() const
{
    return m_RightAngle_06;
}

void Order_Process_Manager::setRightAngle_06(const QString &newRightAngle_06)
{
    if (m_RightAngle_06 == newRightAngle_06)
        return;
    m_RightAngle_06 = newRightAngle_06;
    emit RightAngle_06Changed();
}

QString Order_Process_Manager::MaterialHeight_06() const
{
    return m_MaterialHeight_06;
}

void Order_Process_Manager::setMaterialHeight_06(const QString &newMaterialHeight_06)
{
    if (m_MaterialHeight_06 == newMaterialHeight_06)
        return;
    m_MaterialHeight_06 = newMaterialHeight_06;
    emit MaterialHeight_06Changed();
}

QString Order_Process_Manager::MaterialLength_06() const
{
    return m_MaterialLength_06;
}

void Order_Process_Manager::setMaterialLength_06(const QString &newMaterialLength_06)
{
    if (m_MaterialLength_06 == newMaterialLength_06)
        return;
    m_MaterialLength_06 = newMaterialLength_06;
    emit MaterialLength_06Changed();
}

QString Order_Process_Manager::CutCount_06() const
{
    return m_CutCount_06;
}

void Order_Process_Manager::setCutCount_06(const QString &newCutCount_06)
{
    if (m_CutCount_06 == newCutCount_06)
        return;
    m_CutCount_06 = newCutCount_06;
    emit CutCount_06Changed();
}

QString Order_Process_Manager::LeftAngle_07() const
{
    return m_LeftAngle_07;
}

void Order_Process_Manager::setLeftAngle_07(const QString &newLeftAngle_07)
{
    if (m_LeftAngle_07 == newLeftAngle_07)
        return;
    m_LeftAngle_07 = newLeftAngle_07;
    emit LeftAngle_07Changed();
}

QString Order_Process_Manager::RightAngle_07() const
{
    return m_RightAngle_07;
}

void Order_Process_Manager::setRightAngle_07(const QString &newRightAngle_07)
{
    if (m_RightAngle_07 == newRightAngle_07)
        return;
    m_RightAngle_07 = newRightAngle_07;
    emit RightAngle_07Changed();
}

QString Order_Process_Manager::MaterialHeight_07() const
{
    return m_MaterialHeight_07;
}

void Order_Process_Manager::setMaterialHeight_07(const QString &newMaterialHeight_07)
{
    if (m_MaterialHeight_07 == newMaterialHeight_07)
        return;
    m_MaterialHeight_07 = newMaterialHeight_07;
    emit MaterialHeight_07Changed();
}

QString Order_Process_Manager::MaterialLength_07() const
{
    return m_MaterialLength_07;
}

void Order_Process_Manager::setMaterialLength_07(const QString &newMaterialLength_07)
{
    if (m_MaterialLength_07 == newMaterialLength_07)
        return;
    m_MaterialLength_07 = newMaterialLength_07;
    emit MaterialLength_07Changed();
}

QString Order_Process_Manager::CutCount_07() const
{
    return m_CutCount_07;
}

void Order_Process_Manager::setCutCount_07(const QString &newCutCount_07)
{
    if (m_CutCount_07 == newCutCount_07)
        return;
    m_CutCount_07 = newCutCount_07;
    emit CutCount_07Changed();
}

QString Order_Process_Manager::LeftAngle_08() const
{
    return m_LeftAngle_08;
}

void Order_Process_Manager::setLeftAngle_08(const QString &newLeftAngle_08)
{
    if (m_LeftAngle_08 == newLeftAngle_08)
        return;
    m_LeftAngle_08 = newLeftAngle_08;
    emit LeftAngle_08Changed();
}

QString Order_Process_Manager::RightAngle_08() const
{
    return m_RightAngle_08;
}

void Order_Process_Manager::setRightAngle_08(const QString &newRightAngle_08)
{
    if (m_RightAngle_08 == newRightAngle_08)
        return;
    m_RightAngle_08 = newRightAngle_08;
    emit RightAngle_08Changed();
}

QString Order_Process_Manager::MaterialHeight_08() const
{
    return m_MaterialHeight_08;
}

void Order_Process_Manager::setMaterialHeight_08(const QString &newMaterialHeight_08)
{
    if (m_MaterialHeight_08 == newMaterialHeight_08)
        return;
    m_MaterialHeight_08 = newMaterialHeight_08;
    emit MaterialHeight_08Changed();
}

QString Order_Process_Manager::MaterialLength_08() const
{
    return m_MaterialLength_08;
}

void Order_Process_Manager::setMaterialLength_08(const QString &newMaterialLength_08)
{
    if (m_MaterialLength_08 == newMaterialLength_08)
        return;
    m_MaterialLength_08 = newMaterialLength_08;
    emit MaterialLength_08Changed();
}

QString Order_Process_Manager::CutCount_08() const
{
    return m_CutCount_08;
}

void Order_Process_Manager::setCutCount_08(const QString &newCutCount_08)
{
    if (m_CutCount_08 == newCutCount_08)
        return;
    m_CutCount_08 = newCutCount_08;
    emit CutCount_08Changed();
}

QString Order_Process_Manager::LeftAngle_09() const
{
    return m_LeftAngle_09;
}

void Order_Process_Manager::setLeftAngle_09(const QString &newLeftAngle_09)
{
    if (m_LeftAngle_09 == newLeftAngle_09)
        return;
    m_LeftAngle_09 = newLeftAngle_09;
    emit LeftAngle_09Changed();
}

QString Order_Process_Manager::RightAngle_09() const
{
    return m_RightAngle_09;
}

void Order_Process_Manager::setRightAngle_09(const QString &newRightAngle_09)
{
    if (m_RightAngle_09 == newRightAngle_09)
        return;
    m_RightAngle_09 = newRightAngle_09;
    emit RightAngle_09Changed();
}

QString Order_Process_Manager::MaterialHeight_09() const
{
    return m_MaterialHeight_09;
}

void Order_Process_Manager::setMaterialHeight_09(const QString &newMaterialHeight_09)
{
    if (m_MaterialHeight_09 == newMaterialHeight_09)
        return;
    m_MaterialHeight_09 = newMaterialHeight_09;
    emit MaterialHeight_09Changed();
}

QString Order_Process_Manager::MaterialLength_09() const
{
    return m_MaterialLength_09;
}

void Order_Process_Manager::setMaterialLength_09(const QString &newMaterialLength_09)
{
    if (m_MaterialLength_09 == newMaterialLength_09)
        return;
    m_MaterialLength_09 = newMaterialLength_09;
    emit MaterialLength_09Changed();
}

QString Order_Process_Manager::CutCount_09() const
{
    return m_CutCount_09;
}

void Order_Process_Manager::setCutCount_09(const QString &newCutCount_09)
{
    if (m_CutCount_09 == newCutCount_09)
        return;
    m_CutCount_09 = newCutCount_09;
    emit CutCount_09Changed();
}

QString Order_Process_Manager::LeftAngle_10() const
{
    return m_LeftAngle_10;
}

void Order_Process_Manager::setLeftAngle_10(const QString &newLeftAngle_10)
{
    if (m_LeftAngle_10 == newLeftAngle_10)
        return;
    m_LeftAngle_10 = newLeftAngle_10;
    emit LeftAngle_10Changed();
}

QString Order_Process_Manager::RightAngle_10() const
{
    return m_RightAngle_10;
}

void Order_Process_Manager::setRightAngle_10(const QString &newRightAngle_10)
{
    if (m_RightAngle_10 == newRightAngle_10)
        return;
    m_RightAngle_10 = newRightAngle_10;
    emit RightAngle_10Changed();
}

QString Order_Process_Manager::MaterialHeight_10() const
{
    return m_MaterialHeight_10;
}

void Order_Process_Manager::setMaterialHeight_10(const QString &newMaterialHeight_10)
{
    if (m_MaterialHeight_10 == newMaterialHeight_10)
        return;
    m_MaterialHeight_10 = newMaterialHeight_10;
    emit MaterialHeight_10Changed();
}

QString Order_Process_Manager::MaterialLength_10() const
{
    return m_MaterialLength_10;
}

void Order_Process_Manager::setMaterialLength_10(const QString &newMaterialLength_10)
{
    if (m_MaterialLength_10 == newMaterialLength_10)
        return;
    m_MaterialLength_10 = newMaterialLength_10;
    emit MaterialLength_10Changed();
}

QString Order_Process_Manager::CutCount_10() const
{
    return m_CutCount_10;
}

void Order_Process_Manager::setCutCount_10(const QString &newCutCount_10)
{
    if (m_CutCount_10 == newCutCount_10)
        return;
    m_CutCount_10 = newCutCount_10;
    emit CutCount_10Changed();
}

QString Order_Process_Manager::LeftAngle_11() const
{
    return m_LeftAngle_11;
}

void Order_Process_Manager::setLeftAngle_11(const QString &newLeftAngle_11)
{
    if (m_LeftAngle_11 == newLeftAngle_11)
        return;
    m_LeftAngle_11 = newLeftAngle_11;
    emit LeftAngle_11Changed();
}

QString Order_Process_Manager::RightAngle_11() const
{
    return m_RightAngle_11;
}

void Order_Process_Manager::setRightAngle_11(const QString &newRightAngle_11)
{
    if (m_RightAngle_11 == newRightAngle_11)
        return;
    m_RightAngle_11 = newRightAngle_11;
    emit RightAngle_11Changed();
}

QString Order_Process_Manager::MaterialHeight_11() const
{
    return m_MaterialHeight_11;
}

void Order_Process_Manager::setMaterialHeight_11(const QString &newMaterialHeight_11)
{
    if (m_MaterialHeight_11 == newMaterialHeight_11)
        return;
    m_MaterialHeight_11 = newMaterialHeight_11;
    emit MaterialHeight_11Changed();
}

QString Order_Process_Manager::MaterialLength_11() const
{
    return m_MaterialLength_11;
}

void Order_Process_Manager::setMaterialLength_11(const QString &newMaterialLength_11)
{
    if (m_MaterialLength_11 == newMaterialLength_11)
        return;
    m_MaterialLength_11 = newMaterialLength_11;
    emit MaterialLength_11Changed();
}

QString Order_Process_Manager::CutCount_11() const
{
    return m_CutCount_11;
}

void Order_Process_Manager::setCutCount_11(const QString &newCutCount_11)
{
    if (m_CutCount_11 == newCutCount_11)
        return;
    m_CutCount_11 = newCutCount_11;
    emit CutCount_11Changed();
}

QString Order_Process_Manager::LeftAngle_12() const
{
    return m_LeftAngle_12;
}

void Order_Process_Manager::setLeftAngle_12(const QString &newLeftAngle_12)
{
    if (m_LeftAngle_12 == newLeftAngle_12)
        return;
    m_LeftAngle_12 = newLeftAngle_12;
    emit LeftAngle_12Changed();
}

QString Order_Process_Manager::RightAngle_12() const
{
    return m_RightAngle_12;
}

void Order_Process_Manager::setRightAngle_12(const QString &newRightAngle_12)
{
    if (m_RightAngle_12 == newRightAngle_12)
        return;
    m_RightAngle_12 = newRightAngle_12;
    emit RightAngle_12Changed();
}

QString Order_Process_Manager::MaterialHeight_12() const
{
    return m_MaterialHeight_12;
}

void Order_Process_Manager::setMaterialHeight_12(const QString &newMaterialHeight_12)
{
    if (m_MaterialHeight_12 == newMaterialHeight_12)
        return;
    m_MaterialHeight_12 = newMaterialHeight_12;
    emit MaterialHeight_12Changed();
}

QString Order_Process_Manager::MaterialLength_12() const
{
    return m_MaterialLength_12;
}

void Order_Process_Manager::setMaterialLength_12(const QString &newMaterialLength_12)
{
    if (m_MaterialLength_12 == newMaterialLength_12)
        return;
    m_MaterialLength_12 = newMaterialLength_12;
    emit MaterialLength_12Changed();
}

QString Order_Process_Manager::CutCount_12() const
{
    return m_CutCount_12;
}

void Order_Process_Manager::setCutCount_12(const QString &newCutCount_12)
{
    if (m_CutCount_12 == newCutCount_12)
        return;
    m_CutCount_12 = newCutCount_12;
    emit CutCount_12Changed();
}

QString Order_Process_Manager::LeftAngle_13() const
{
    return m_LeftAngle_13;
}

void Order_Process_Manager::setLeftAngle_13(const QString &newLeftAngle_13)
{
    if (m_LeftAngle_13 == newLeftAngle_13)
        return;
    m_LeftAngle_13 = newLeftAngle_13;
    emit LeftAngle_13Changed();
}

QString Order_Process_Manager::RightAngle_13() const
{
    return m_RightAngle_13;
}

void Order_Process_Manager::setRightAngle_13(const QString &newRightAngle_13)
{
    if (m_RightAngle_13 == newRightAngle_13)
        return;
    m_RightAngle_13 = newRightAngle_13;
    emit RightAngle_13Changed();
}

QString Order_Process_Manager::MaterialHeight_13() const
{
    return m_MaterialHeight_13;
}

void Order_Process_Manager::setMaterialHeight_13(const QString &newMaterialHeight_13)
{
    if (m_MaterialHeight_13 == newMaterialHeight_13)
        return;
    m_MaterialHeight_13 = newMaterialHeight_13;
    emit MaterialHeight_13Changed();
}

QString Order_Process_Manager::MaterialLength_13() const
{
    return m_MaterialLength_13;
}

void Order_Process_Manager::setMaterialLength_13(const QString &newMaterialLength_13)
{
    if (m_MaterialLength_13 == newMaterialLength_13)
        return;
    m_MaterialLength_13 = newMaterialLength_13;
    emit MaterialLength_13Changed();
}

QString Order_Process_Manager::CutCount_13() const
{
    return m_CutCount_13;
}

void Order_Process_Manager::setCutCount_13(const QString &newCutCount_13)
{
    if (m_CutCount_13 == newCutCount_13)
        return;
    m_CutCount_13 = newCutCount_13;
    emit CutCount_13Changed();
}

QString Order_Process_Manager::LeftAngle_14() const
{
    return m_LeftAngle_14;
}

void Order_Process_Manager::setLeftAngle_14(const QString &newLeftAngle_14)
{
    if (m_LeftAngle_14 == newLeftAngle_14)
        return;
    m_LeftAngle_14 = newLeftAngle_14;
    emit LeftAngle_14Changed();
}

QString Order_Process_Manager::RightAngle_14() const
{
    return m_RightAngle_14;
}

void Order_Process_Manager::setRightAngle_14(const QString &newRightAngle_14)
{
    if (m_RightAngle_14 == newRightAngle_14)
        return;
    m_RightAngle_14 = newRightAngle_14;
    emit RightAngle_14Changed();
}

QString Order_Process_Manager::MaterialHeight_14() const
{
    return m_MaterialHeight_14;
}

void Order_Process_Manager::setMaterialHeight_14(const QString &newMaterialHeight_14)
{
    if (m_MaterialHeight_14 == newMaterialHeight_14)
        return;
    m_MaterialHeight_14 = newMaterialHeight_14;
    emit MaterialHeight_14Changed();
}

QString Order_Process_Manager::MaterialLength_14() const
{
    return m_MaterialLength_14;
}

void Order_Process_Manager::setMaterialLength_14(const QString &newMaterialLength_14)
{
    if (m_MaterialLength_14 == newMaterialLength_14)
        return;
    m_MaterialLength_14 = newMaterialLength_14;
    emit MaterialLength_14Changed();
}

QString Order_Process_Manager::CutCount_14() const
{
    return m_CutCount_14;
}

void Order_Process_Manager::setCutCount_14(const QString &newCutCount_14)
{
    if (m_CutCount_14 == newCutCount_14)
        return;
    m_CutCount_14 = newCutCount_14;
    emit CutCount_14Changed();
}

QString Order_Process_Manager::LeftAngle_15() const
{
    return m_LeftAngle_15;
}

void Order_Process_Manager::setLeftAngle_15(const QString &newLeftAngle_15)
{
    if (m_LeftAngle_15 == newLeftAngle_15)
        return;
    m_LeftAngle_15 = newLeftAngle_15;
    emit LeftAngle_15Changed();
}

QString Order_Process_Manager::RightAngle_15() const
{
    return m_RightAngle_15;
}

void Order_Process_Manager::setRightAngle_15(const QString &newRightAngle_15)
{
    if (m_RightAngle_15 == newRightAngle_15)
        return;
    m_RightAngle_15 = newRightAngle_15;
    emit RightAngle_15Changed();
}

QString Order_Process_Manager::MaterialHeight_15() const
{
    return m_MaterialHeight_15;
}

void Order_Process_Manager::setMaterialHeight_15(const QString &newMaterialHeight_15)
{
    if (m_MaterialHeight_15 == newMaterialHeight_15)
        return;
    m_MaterialHeight_15 = newMaterialHeight_15;
    emit MaterialHeight_15Changed();
}

QString Order_Process_Manager::MaterialLength_15() const
{
    return m_MaterialLength_15;
}

void Order_Process_Manager::setMaterialLength_15(const QString &newMaterialLength_15)
{
    if (m_MaterialLength_15 == newMaterialLength_15)
        return;
    m_MaterialLength_15 = newMaterialLength_15;
    emit MaterialLength_15Changed();
}

QString Order_Process_Manager::CutCount_15() const
{
    return m_CutCount_15;
}

void Order_Process_Manager::setCutCount_15(const QString &newCutCount_15)
{
    if (m_CutCount_15 == newCutCount_15)
        return;
    m_CutCount_15 = newCutCount_15;
    emit CutCount_15Changed();
}

QString Order_Process_Manager::LeftAngle_16() const
{
    return m_LeftAngle_16;
}

void Order_Process_Manager::setLeftAngle_16(const QString &newLeftAngle_16)
{
    if (m_LeftAngle_16 == newLeftAngle_16)
        return;
    m_LeftAngle_16 = newLeftAngle_16;
    emit LeftAngle_16Changed();
}

QString Order_Process_Manager::RightAngle_16() const
{
    return m_RightAngle_16;
}

void Order_Process_Manager::setRightAngle_16(const QString &newRightAngle_16)
{
    if (m_RightAngle_16 == newRightAngle_16)
        return;
    m_RightAngle_16 = newRightAngle_16;
    emit RightAngle_16Changed();
}

QString Order_Process_Manager::MaterialHeight_16() const
{
    return m_MaterialHeight_16;
}

void Order_Process_Manager::setMaterialHeight_16(const QString &newMaterialHeight_16)
{
    if (m_MaterialHeight_16 == newMaterialHeight_16)
        return;
    m_MaterialHeight_16 = newMaterialHeight_16;
    emit MaterialHeight_16Changed();
}

QString Order_Process_Manager::MaterialLength_16() const
{
    return m_MaterialLength_16;
}

void Order_Process_Manager::setMaterialLength_16(const QString &newMaterialLength_16)
{
    if (m_MaterialLength_16 == newMaterialLength_16)
        return;
    m_MaterialLength_16 = newMaterialLength_16;
    emit MaterialLength_16Changed();
}

QString Order_Process_Manager::CutCount_16() const
{
    return m_CutCount_16;
}

void Order_Process_Manager::setCutCount_16(const QString &newCutCount_16)
{
    if (m_CutCount_16 == newCutCount_16)
        return;
    m_CutCount_16 = newCutCount_16;
    emit CutCount_16Changed();
}

QString Order_Process_Manager::LeftAngle_17() const
{
    return m_LeftAngle_17;
}

void Order_Process_Manager::setLeftAngle_17(const QString &newLeftAngle_17)
{
    if (m_LeftAngle_17 == newLeftAngle_17)
        return;
    m_LeftAngle_17 = newLeftAngle_17;
    emit LeftAngle_17Changed();
}

QString Order_Process_Manager::RightAngle_17() const
{
    return m_RightAngle_17;
}

void Order_Process_Manager::setRightAngle_17(const QString &newRightAngle_17)
{
    if (m_RightAngle_17 == newRightAngle_17)
        return;
    m_RightAngle_17 = newRightAngle_17;
    emit RightAngle_17Changed();
}

QString Order_Process_Manager::MaterialHeight_17() const
{
    return m_MaterialHeight_17;
}

void Order_Process_Manager::setMaterialHeight_17(const QString &newMaterialHeight_17)
{
    if (m_MaterialHeight_17 == newMaterialHeight_17)
        return;
    m_MaterialHeight_17 = newMaterialHeight_17;
    emit MaterialHeight_17Changed();
}

QString Order_Process_Manager::MaterialLength_17() const
{
    return m_MaterialLength_17;
}

void Order_Process_Manager::setMaterialLength_17(const QString &newMaterialLength_17)
{
    if (m_MaterialLength_17 == newMaterialLength_17)
        return;
    m_MaterialLength_17 = newMaterialLength_17;
    emit MaterialLength_17Changed();
}

QString Order_Process_Manager::CutCount_17() const
{
    return m_CutCount_17;
}

void Order_Process_Manager::setCutCount_17(const QString &newCutCount_17)
{
    if (m_CutCount_17 == newCutCount_17)
        return;
    m_CutCount_17 = newCutCount_17;
    emit CutCount_17Changed();
}

QString Order_Process_Manager::LeftAngle_18() const
{
    return m_LeftAngle_18;
}

void Order_Process_Manager::setLeftAngle_18(const QString &newLeftAngle_18)
{
    if (m_LeftAngle_18 == newLeftAngle_18)
        return;
    m_LeftAngle_18 = newLeftAngle_18;
    emit LeftAngle_18Changed();
}

QString Order_Process_Manager::RightAngle_18() const
{
    return m_RightAngle_18;
}

void Order_Process_Manager::setRightAngle_18(const QString &newRightAngle_18)
{
    if (m_RightAngle_18 == newRightAngle_18)
        return;
    m_RightAngle_18 = newRightAngle_18;
    emit RightAngle_18Changed();
}

QString Order_Process_Manager::MaterialHeight_18() const
{
    return m_MaterialHeight_18;
}

void Order_Process_Manager::setMaterialHeight_18(const QString &newMaterialHeight_18)
{
    if (m_MaterialHeight_18 == newMaterialHeight_18)
        return;
    m_MaterialHeight_18 = newMaterialHeight_18;
    emit MaterialHeight_18Changed();
}

QString Order_Process_Manager::MaterialLength_18() const
{
    return m_MaterialLength_18;
}

void Order_Process_Manager::setMaterialLength_18(const QString &newMaterialLength_18)
{
    if (m_MaterialLength_18 == newMaterialLength_18)
        return;
    m_MaterialLength_18 = newMaterialLength_18;
    emit MaterialLength_18Changed();
}

QString Order_Process_Manager::CutCount_18() const
{
    return m_CutCount_18;
}

void Order_Process_Manager::setCutCount_18(const QString &newCutCount_18)
{
    if (m_CutCount_18 == newCutCount_18)
        return;
    m_CutCount_18 = newCutCount_18;
    emit CutCount_18Changed();
}

QString Order_Process_Manager::LeftAngle_19() const
{
    return m_LeftAngle_19;
}

void Order_Process_Manager::setLeftAngle_19(const QString &newLeftAngle_19)
{
    if (m_LeftAngle_19 == newLeftAngle_19)
        return;
    m_LeftAngle_19 = newLeftAngle_19;
    emit LeftAngle_19Changed();
}

QString Order_Process_Manager::RightAngle_19() const
{
    return m_RightAngle_19;
}

void Order_Process_Manager::setRightAngle_19(const QString &newRightAngle_19)
{
    if (m_RightAngle_19 == newRightAngle_19)
        return;
    m_RightAngle_19 = newRightAngle_19;
    emit RightAngle_19Changed();
}

QString Order_Process_Manager::MaterialHeight_19() const
{
    return m_MaterialHeight_19;
}

void Order_Process_Manager::setMaterialHeight_19(const QString &newMaterialHeight_19)
{
    if (m_MaterialHeight_19 == newMaterialHeight_19)
        return;
    m_MaterialHeight_19 = newMaterialHeight_19;
    emit MaterialHeight_19Changed();
}

QString Order_Process_Manager::MaterialLength_19() const
{
    return m_MaterialLength_19;
}

void Order_Process_Manager::setMaterialLength_19(const QString &newMaterialLength_19)
{
    if (m_MaterialLength_19 == newMaterialLength_19)
        return;
    m_MaterialLength_19 = newMaterialLength_19;
    emit MaterialLength_19Changed();
}

QString Order_Process_Manager::CutCount_19() const
{
    return m_CutCount_19;
}

void Order_Process_Manager::setCutCount_19(const QString &newCutCount_19)
{
    if (m_CutCount_19 == newCutCount_19)
        return;
    m_CutCount_19 = newCutCount_19;
    emit CutCount_19Changed();
}

QString Order_Process_Manager::LeftAngle_20() const
{
    return m_LeftAngle_20;
}

void Order_Process_Manager::setLeftAngle_20(const QString &newLeftAngle_20)
{
    if (m_LeftAngle_20 == newLeftAngle_20)
        return;
    m_LeftAngle_20 = newLeftAngle_20;
    emit LeftAngle_20Changed();
}

QString Order_Process_Manager::RightAngle_20() const
{
    return m_RightAngle_20;
}

void Order_Process_Manager::setRightAngle_20(const QString &newRightAngle_20)
{
    if (m_RightAngle_20 == newRightAngle_20)
        return;
    m_RightAngle_20 = newRightAngle_20;
    emit RightAngle_20Changed();
}

QString Order_Process_Manager::MaterialHeight_20() const
{
    return m_MaterialHeight_20;
}

void Order_Process_Manager::setMaterialHeight_20(const QString &newMaterialHeight_20)
{
    if (m_MaterialHeight_20 == newMaterialHeight_20)
        return;
    m_MaterialHeight_20 = newMaterialHeight_20;
    emit MaterialHeight_20Changed();
}

QString Order_Process_Manager::MaterialLength_20() const
{
    return m_MaterialLength_20;
}

void Order_Process_Manager::setMaterialLength_20(const QString &newMaterialLength_20)
{
    if (m_MaterialLength_20 == newMaterialLength_20)
        return;
    m_MaterialLength_20 = newMaterialLength_20;
    emit MaterialLength_20Changed();
}

QString Order_Process_Manager::CutCount_20() const
{
    return m_CutCount_20;
}

void Order_Process_Manager::setCutCount_20(const QString &newCutCount_20)
{
    if (m_CutCount_20 == newCutCount_20)
        return;
    m_CutCount_20 = newCutCount_20;
    emit CutCount_20Changed();
}

int Order_Process_Manager::packetNumber() const
{
    return m_packetNumber;
}

void Order_Process_Manager::setPacketNumber(int newPacketNumber)
{
    if (m_packetNumber == newPacketNumber)
        return;
    m_packetNumber = newPacketNumber;
    emit packetNumberChanged();
}
